TurboRisk programs are text files with extension .TRP that contain instructions in (a subset of) PASCAL. TurboRisk uses the Delphi-style Pascal interpreter (Delphin), free for non-commercial uses, by S.Kurinny & S.Kostinsky.
The language is essentially PASCAL. If you know PASCAL you should not have any particular program. Study the SIMPLE.TRP example program to have a starting point. A PASCAL course is far beyond the scope of this document (and my possibilities!).
A very important restriction you must know is that the interpreter does not support ARRAYS.
Program structure
-----------------
Each TurboRisk program MUST CONTAIN five procedures with predefined name that are called by TurboRisk when the computer player is expected to take some decision. Each procedure receives parameters and outputs results through global variables with pre-defined name too.
The ASSIGNMENT procedure is called during the initial assignment of territories to know which is the program's choice. Return the result in the ToTerritory global variable.
The PLACEMENT procedure is called at the beginning of each turn to decide where to place new armies. It is called N times, each one to place a single army, until all new armies are placed. Return the result in the ToTerritory global variable.
The ATTACK procedure is called at attack time. Each call to ATTACK corresponds to a single throw of the dice. Return the program's choice in the FromTerritory and ToTerritory global variables. Set FromTerritory to 0 if you decide not to attack and end your attack phase.
The OCCUPATION procedure is called after a successful attack. The global variables FromTerritory and ToTerritory are properly set by TurboRisk when entering the routine. Return the number of armies you want to move in the Armies global variable.
The FORTIFICATION procedure is called after the attack phase. Return the program's choice in the FromTerritory, ToTerritory and Armies global variables. Set FromTerritory to 0 if you decide not to move any army and end your turn.
Variables
---------
You can define your own variables, procedures and functions. Please remember that all your variables will be LOCAL variables, I mean erased between calls. TurboRisk provides a place to store GLOBAL values through the UBufferSet and UBufferGet functions explained below. You have 50 variant buffers for your own use.
TurboRisk interface routines
----------------------------
TurboRisk provides a large set of procedures and functions that let your program know things about territories, players, continents and status of the game.
Territories are numbered from 1 to 42, players from 1 to 10, continents from 1 to 6.
Territories
-----------
1 Alaska
2 Northwest Territory
3 Greenland
4 Alberta
5 Ontario
6 Quebec
7 Western US
8 Eastern US
9 Central America
10 Venezuela
11 Peru
12 Brazil
13 Argentina
14 North Africa
15 Egypt
16 East Africa
17 Congo
18 South Africa
19 Madagascar
20 Iceland
21 Scandinavia
22 Ukraine
23 Northern Europe
24 Great Britain
25 Western Europe
26 Southern Europe
27 Middle East
28 Yamal-Nemets
29 Kazakhstan
30 India
31 Siam
32 China
33 Mongolia
34 Taymyr
35 Yakut
36 Buryat
37 Koryak
38 Japan
39 Indonesia
40 Western Australia
41 Eastern Australia
42 New Guinea
Continents
----------
1 North America
2 South America
3 Europe
4 Africa
5 Asia
6 Australia
Routines about Territories
--------------------------
function TName(T: integer): string;
returns the name of territory T, '?' if T is out of range
function TOwner(T: integer): integer;
returns the owner of territory T, 0 if T is unassigned, -1 if T is out of range
function TArmies(T: integer): integer;
returns the number of armies on territory T, 0 if T is unassigned, -1 if T is out of range
function TContinent(T: integer): integer;
returns the ID of the continent which territory T belongs to, -1 if T is out of range
function TBordersCount(T: integer): integer;
returns the number of borders of territory T (max 6), -1 if T is out of range
function TBorder(T,B: integer): integer;
returns bordering territory #B of territory T, -1 if T or B are out of range
function TIsBordering(T1,T2: integer): boolean;
returns true if territory T1 is bordering on territory T2, false if not or T or B are out of range
function TIsFront(T: integer): boolean;
returns true if territory T is owned by current player and has at least one bordering territory occupied by opponents, false if not or T is out of range
function TIsMine(T: integer): boolean;
returns true if territory T is owned by current player, false if not or T is out of range
function TFrontsCount(T: integer): integer;
returns the number of territories bordering on territory T which are occupied by opponents, -1 if T is out of range
function TFront(T,F: integer): integer;
returns bordering enemy territory #F of territory T, -1 if T or F are out of range
function TStrongestFront(T: integer; var ET,EA: integer): boolean;
returns false if T is out of range, otherwise true the "var" variables will contain information on territory T:
ET: number of the strongest enemy's territory bordering on T, 0 if T has not fronts
EA: enemy's armies on territory ET
(unassigned territories are not counted)
function TWeakestFront(T: integer; var ET,EA: integer): boolean;
returns false if T is out of range, otherwise true
the "var" variables will contain information on territory T:
ET: number of the weakest enemy's territory bordering on T, 0 if T has not fronts
EA: enemy's armies on territory ET
(unassigned territories are not counted)
function TPressure(T: integer): integer;
returns the total number of enemy armies bordering on territory T, -1 if T is out of range
Routines about Players
----------------------
function PMe: integer;
returns the ID of the player in turn
function PName(P: integer): string;
returns player's P name, '?' if P is out of range
function PProgram(P: integer): string;
returns player's P program file name (lowercase) if player is computer,
'human' if human, '?' if P is out of range
function PActive(P: integer): boolean;
returns true if player P is active, false if not or P is out of range
function PHuman(P: integer): boolean;
returns true if P is a human player, false if P is computer player or P is out of range
function PArmiesCount(P: integer): integer;
returns the number of armies totally controlled by player P on all of its territories, -1 if P is out of range
function PNewArmies(P: integer): integer;
returns the number of armies which player P still has to place on his territories, -1 if P is out of range
function PTerritoriesCount(P: integer): integer;
returns the number of territories controlled by player P, -1 if P is out of range
Routines about Continents
-------------------------
function COwner(C: integer): integer;
returns the owner of continent C, 0 if C has more then one occupant, -1 if C is out of range
function CBonus(C: integer): integer;
returns the number of armies (per turn) which the control of continent C entitles to, -1 if C is out of range
function CTerritoriesCount(C: integer): integer;
returns the number of territories belonging to continent C, -1 if C is out of range
function CTerritory(C,T: integer): integer;
returns the ID of territory #T belonging to continent C, -1 if T or C are out of range
function CBordersCount(C: integer): integer;
returns the number of territories bordering on continent C (max 6), -1 if C is out of range
function CBorder(C,B: integer): integer;
returns bordering territory #B of continent C, -1 if C or B are out of range
function CAnalysis(C: integer; var PT,PA,ET,EA: integer): boolean;
returns false if C is out of range, otherwise true
the "var" variables will contain information on continent C:
PT: player in turn's number of territories on continent C
PA: player in turn's armies on continent C
ET: enemy's number of territories on continent C
EA: enemy's armies on continent C
(unassigned territories are not counted)
function CLeader(C: integer; var P,T,A: integer): boolean;
returns false if C is out of range, otherwise true
the "var" variables will contain information on continent C:
P: leader = player who controls greatest number of territories
A: leader's armies on continent C
T: leader's number of territories on continent C
if two or more players own the same number of territories, the leader is the one which has more armies. If continent is empty (all territories unissegned) P returns 0.
(unassigned territories are not counted)
Routines about Status of the game
---------------------------------
function SConquest: boolean;
returns true if current player has conquered at least one territory on current turn, otherwise false
function SPlayersCount: integer;
returns the number of active players
Other routines (utilities)
--------------------------
procedure UMessage(M: array);
display a modal window with message M
procedure ULog(M: array);
write message M on the log
procedure UBufferSet(B: integer; V: variant);
set B element of Player's buffer to value V (B ranges from 1 to 50)
function UBufferGet(B: integer): variant;
returns Bth element of Player's buffer, -1 if B is out of range (B ranges from 1 to 50)
function URandom(R: integer): variant;
if R>0 returns an integer random number I in the range 0 <= I < R, otherwise
returns a real-type number X in the range 0 <= X < 1
